{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/xingyao6/opt/miniconda3/envs/llm-agent/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from glob import glob\n",
    "import json\n",
    "import os\n",
    "import re\n",
    "import sys\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "from typing import List, Dict, Mapping, Tuple, Union, Optional\n",
    "from transformers import AutoTokenizer\n",
    "\n",
    "tqdm.pandas()\n",
    "ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.getcwd())))) # Should be your path to the repo root\n",
    "sys.path.insert(0, ROOT_DIR)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 12 trajectory files\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8580 trajectories\n"
     ]
    }
   ],
   "source": [
    "trajectory_files = glob(os.path.join(ROOT_DIR, \"data/trajectories/medium_instances/*.jsonl\"))\n",
    "# trajectory_files = glob(os.path.join(ROOT_DIR, \"data/trajectories/easy_instances/*.jsonl\"))\n",
    "# trajectory_files = glob(os.path.join(ROOT_DIR, \"data/trajectories/hard_gpt4_instances/*.jsonl\"))\n",
    "print(f\"Found {len(trajectory_files)} trajectory files\")\n",
    "# read everything into a dataframe\n",
    "dfs = []\n",
    "for trajectory_file in trajectory_files:\n",
    "    with open(trajectory_file, \"r\") as f:\n",
    "        for line in f:\n",
    "            line = json.loads(line)\n",
    "            dfs.append(line)\n",
    "df = pd.DataFrame(dfs)\n",
    "print(f\"Found {len(df)} trajectories\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special Symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32002"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer = AutoTokenizer.from_pretrained(\"/shared/nas/data/m1/shared-resource/llm/meta-llama/Llama-2-7b-hf/\")\n",
    "\n",
    "# follow https://github.com/openai/openai-python/blob/main/chatml.md\n",
    "# and https://huggingface.co/OpenAssistant/codellama-13b-oasst-sft-v10\n",
    "INST_START = \"<|im_start|>\"\n",
    "INST_END = \"<|im_end|>\"\n",
    "\n",
    "\"\"\"\n",
    "<|im_start|>system\n",
    "{system_message}<|im_end|>\n",
    "<|im_start|>user\n",
    "{prompt}<|im_end|>\n",
    "<|im_start|>assistant\n",
    "\"\"\"\n",
    "\n",
    "# add the special tokens\n",
    "tokenizer.add_special_tokens({\"additional_special_tokens\": [INST_START, INST_END]})\n",
    "len(tokenizer)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter Traj for Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "alfworld                    2099\n",
       "hotpotqa                    1630\n",
       "strategyqa                  1595\n",
       "wiki_table_questions        1129\n",
       "APPS                         667\n",
       "algebra                      467\n",
       "number_theory                270\n",
       "intermediate_algebra         236\n",
       "prealgebra                   234\n",
       "counting_and_probability     120\n",
       "precalculus                   73\n",
       "geometry                      60\n",
       "Name: task_name, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"task_name\"].value_counts()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length (before): 8580\n",
      "Length (after): 6985\n",
      "alfworld                    2099\n",
      "hotpotqa                    1630\n",
      "wiki_table_questions        1129\n",
      "APPS                         667\n",
      "algebra                      467\n",
      "number_theory                270\n",
      "intermediate_algebra         236\n",
      "prealgebra                   234\n",
      "counting_and_probability     120\n",
      "precalculus                   73\n",
      "geometry                      60\n",
      "Name: task_name, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# selected = df.query(\"task_name == 'APPS'\")\n",
    "print(\"Length (before):\", len(df))\n",
    "SELECT_TASK = [\n",
    "    \"alfworld\",\n",
    "    # \"strategyqa\",  # leave it out, has a lot short cuts (i.e., model cannot find answer from search)\n",
    "    \"hotpotqa\",\n",
    "    \"wiki_table_questions\", \n",
    "    \"APPS\", # Code\n",
    "    \"algebra\", \"number_theory\", \"prealgebra\", \"intermediate_algebra\", \"counting_and_probability\", \"precalculus\", \"geometry\"  # MATH\n",
    "]\n",
    "selected = df.query(\"task_name in @SELECT_TASK\")\n",
    "print(\"Length (after):\", len(selected))\n",
    "print(selected[\"task_name\"].value_counts())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length (before): 6985\n",
      "Length (after remove invalid_action): 6955\n",
      "Length (after remove strategyqa propose=2 success): 6955\n"
     ]
    }
   ],
   "source": [
    "# Straightforward filtering\n",
    "assert selected[\"success\"].nunique() == 1, \"There should only be one value for success (1)\"\n",
    "\n",
    "print(\"Length (before):\", len(selected))\n",
    "# 1. remove all tasks that are have (n_turns - 1) invalid_action\n",
    "selected = selected[~((selected[\"n_turns\"] - 1) == selected[\"invalid_action\"])]\n",
    "print(\"Length (after remove invalid_action):\", len(selected))\n",
    "\n",
    "# 2. remove strategyqa tasks that success with proposed solution == 2\n",
    "# UPDATE: We obanonded this dataset entirely\n",
    "selected = selected[~((selected[\"task_name\"] == \"strategyqa\") & (selected[\"propose_solution\"] == 2))]\n",
    "print(\"Length (after remove strategyqa propose=2 success):\", len(selected))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_filtering_heuritics(row) -> bool:\n",
    "    \"\"\"Return true if the state should be kept.\"\"\"\n",
    "    state = row[\"state\"]\n",
    "    history = state[\"history\"]\n",
    "    # print(f\"History length: {len(history)}\")\n",
    "    # exclude the first system message + instruction AND final assistant message (with no user response)\n",
    "    history = history[1:-1]\n",
    "    \n",
    "    # 1. This is a werid case where the assistant is not responding to the user\n",
    "    if len(history) % 2 != 0:\n",
    "        print(f\"[Instance Removed] History length is odd: {len(history)}\")\n",
    "        return False\n",
    "    # assert len(history) % 2 == 0, f\"History should be even length. But got {len(history)}.\"\n",
    "\n",
    "    # Collect assistant and user messages\n",
    "    paired_assistant_user_pairs = []\n",
    "    for i in range(0, len(history), 2):\n",
    "        assistant = history[i][\"content\"]\n",
    "        user = history[i + 1][\"content\"]\n",
    "        # print(f\"ASSISTANT:\\n{assistant}\")\n",
    "        # print(f\"USER:\\n{user}\")\n",
    "        paired_assistant_user_pairs.append((assistant, user))\n",
    "\n",
    "    # 2. Remove all <execute> outputs that *all* causes some sort of error (and eventually got it right?)\n",
    "    # This keeps the ones that are eventually correct and may or may not have errors in the beginning\n",
    "    if all(\n",
    "        (\n",
    "        \"<solution>\" in assistant_content \n",
    "         or (\"<execute>\" in assistant_content and \"Error\" in user_content)\n",
    "        )\n",
    "        for assistant_content, user_content in paired_assistant_user_pairs\n",
    "    ):  \n",
    "        return False\n",
    "\n",
    "    return True\n",
    "\n",
    "def convert_state_to_traj(state):\n",
    "    STRIP_WORDS = [\n",
    "        \"Assistant:\",\n",
    "    ]\n",
    "    history = state[\"history\"]\n",
    "    res = \"\"\n",
    "\n",
    "    for i, turn in enumerate(history):\n",
    "        role = turn[\"role\"]\n",
    "        text = turn[\"content\"].strip()\n",
    "        for word in STRIP_WORDS:\n",
    "            text = text.lstrip(word)\n",
    "        text = text.strip()\n",
    "        if i == 0:\n",
    "            assert role == \"user\"\n",
    "            # specifically handle the first turn\n",
    "            splited_text = text.split(\"\\n---\\n\\nTask:\")\n",
    "            assert len(splited_text) == 3, f\"Expecting 3 parts. But got {len(splited_text)} parts: \\n{text}\"\n",
    "            system_message, in_context_example, task = splited_text\n",
    "            res += f\"{INST_START}system\\n{system_message.strip()}{INST_END}\\n\"\n",
    "            res += f\"{INST_START}user\\nTask:\\n{task.strip()}{INST_END}\\n\"\n",
    "\n",
    "        elif role == \"user\":\n",
    "            res += f\"{INST_START}user\\n{text}{INST_END}\\n\"\n",
    "        elif role == \"assistant\":\n",
    "            res += f\"{INST_START}assistant\\n{text}{INST_END}\\n\"\n",
    "    return res\n",
    "\n",
    "SYSTEM_MSG_TO_REPLACE = \"\"\"At each turn, you should first provide your step-by-step thinking for solving the task. Your thought process should be enclosed using \"<thought>\" tag, for example: <thought> I need to print \"Hello World!\" </thought>.\n",
    "\n",
    "After that, you have two options:\"\"\"\n",
    "\n",
    "SYSTEM_MSG_NEW = \"\"\"At each turn, you should first provide your step-by-step thinking for solving the task. After that, you have two options:\"\"\"\n",
    "\n",
    "def convert_state_to_traj(state) -> List[Mapping[str, str]]:\n",
    "    STRIP_WORDS = [\n",
    "        \"Assistant:\",\n",
    "    ]\n",
    "    history = state[\"history\"]\n",
    "    res = []\n",
    "\n",
    "    def _fix_weird_str(string):\n",
    "        string = string.replace(\"Assistant\\uff1a\", \"\")\n",
    "        string = string.replace(\"Assistant:\", \"\")\n",
    "        return string\n",
    "\n",
    "    for i, turn in enumerate(history):\n",
    "        role = turn[\"role\"]\n",
    "        text = turn[\"content\"].strip()\n",
    "        for word in STRIP_WORDS:\n",
    "            text = text.lstrip(word)\n",
    "        text = text.strip()\n",
    "        if i == 0:\n",
    "            assert role == \"user\"\n",
    "            # specifically handle the first turn\n",
    "            splited_text = text.split(\"\\n---\\n\\nTask:\")\n",
    "            assert len(splited_text) == 3, f\"Expecting 3 parts. But got {len(splited_text)} parts: \\n{text}\"\n",
    "            system_message, in_context_example, task = splited_text\n",
    "            system_message = system_message.replace(SYSTEM_MSG_TO_REPLACE, SYSTEM_MSG_NEW)\n",
    "            # res += f\"{INST_START}system\\n{system_message.strip()}{INST_END}\\n\"\n",
    "            res.append({\n",
    "                \"role\": \"system\",\n",
    "                \"content\": system_message.strip()\n",
    "            })\n",
    "            # res += f\"{INST_START}user\\nTask:\\n{task.strip()}{INST_END}\\n\"\n",
    "            res.append({\n",
    "                \"role\": \"user\",\n",
    "                \"content\": f\"Task:\\n{task.strip()}\"\n",
    "            })\n",
    "\n",
    "        elif role == \"user\":\n",
    "            res.append({\n",
    "                \"role\": \"user\",\n",
    "                \"content\": text\n",
    "            })\n",
    "        elif role == \"assistant\":\n",
    "            # replace <thought> and </thought> with empty string, but keep the content between them\n",
    "            # if is on a separate line, remove the line\n",
    "            # do not capture the space right after <thought> and before </thought>\n",
    "            text = re.sub(r\"<thought>(.*?)</thought>\", lambda match: match.group(1).strip(), text, flags=re.DOTALL)\n",
    "\n",
    "            res.append({\n",
    "                \"role\": \"assistant\",\n",
    "                \"content\": _fix_weird_str(text)\n",
    "            })\n",
    "    return res\n",
    "\n",
    "def format_traj_to_str(traj: List[Mapping[str, str]]) -> str:\n",
    "    res = \"\"\n",
    "    for turn in traj:\n",
    "        res += f\"{INST_START}{turn['role']}\\n{turn['content']}{INST_END}\\n\"\n",
    "    return res\n",
    "\n",
    "def visualize_traj(traj: List[Mapping[str, str]]):\n",
    "    print(\"==========================\")\n",
    "    for turn in traj:\n",
    "        if turn[\"role\"] == \"user\":\n",
    "            print(\"\\033[1;34;40m\" + f\"USER:\\n{turn['content']}\" + \"\\033[0m\")\n",
    "            print(\"==========================\")\n",
    "        elif turn[\"role\"] == \"assistant\":\n",
    "            # green for assistant\n",
    "            print(\"\\033[1;32;40m\" + f\"ASSISTANT:\\n{turn['content']}\" + \"\\033[0m\")\n",
    "            print(\"==========================\")\n",
    "        elif turn[\"role\"] == \"system\":\n",
    "            # yellow for system\n",
    "            print(\"\\033[1;33;40m\" + f\"SYSTEM:\\n{turn['content']}\" + \"\\033[0m\")\n",
    "            print(\"==========================\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Instance Removed] History length is odd: 5\n",
      "[Instance Removed] History length is odd: 5\n",
      "[Instance Removed] History length is odd: 5\n",
      "[Instance Removed] History length is odd: 7\n",
      "[Instance Removed] History length is odd: 5\n",
      "[Instance Removed] History length is odd: 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True     6728\n",
       "False     227\n",
       "Name: keep, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selected = selected.assign(keep=selected.apply(data_filtering_heuritics, axis=1))\n",
    "selected[\"keep\"].value_counts()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "task_name                 keep \n",
       "APPS                      True      573\n",
       "                          False      69\n",
       "alfworld                  True     2031\n",
       "                          False      68\n",
       "algebra                   True      462\n",
       "                          False       5\n",
       "counting_and_probability  True      119\n",
       "geometry                  True       59\n",
       "hotpotqa                  True     1618\n",
       "                          False      11\n",
       "intermediate_algebra      True      234\n",
       "                          False       2\n",
       "number_theory             True      269\n",
       "                          False       1\n",
       "prealgebra                True      227\n",
       "                          False       5\n",
       "precalculus               True       71\n",
       "                          False       2\n",
       "wiki_table_questions      True     1065\n",
       "                          False      64\n",
       "Name: keep, dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selected.groupby(\"task_name\")[\"keep\"].value_counts()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Look at filtered data\n",
    "# visualize_traj_str(convert_state_to_traj_str(selected[~selected[\"keep\"]].sample(1).iloc[0][\"state\"]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process Kept Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of data points: 6728\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "task_name\n",
       "APPS                         573\n",
       "alfworld                    2031\n",
       "algebra                      462\n",
       "counting_and_probability     119\n",
       "geometry                      59\n",
       "hotpotqa                    1618\n",
       "intermediate_algebra         234\n",
       "number_theory                269\n",
       "prealgebra                   227\n",
       "precalculus                   71\n",
       "wiki_table_questions        1065\n",
       "Name: id, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "task_type\n",
       "code_generation     573\n",
       "decision_making    2031\n",
       "reasoning          3059\n",
       "tabular            1065\n",
       "Name: id, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='task_name'>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Look at keep data\n",
    "kept_data = selected[selected[\"keep\"]]\n",
    "# assign a unique id to each data point\n",
    "def get_id(row):\n",
    "    return f\"{row['task_type']}/{row['task_name']}/{row['task_id']}/{row['agent_model_name']}/{row['exp_setting']}\"\n",
    "kept_data = kept_data.assign(id=kept_data.apply(get_id, axis=1))\n",
    "print(f\"Total number of data points: {len(kept_data)}\")\n",
    "\n",
    "# distribution of data points\n",
    "# kept_data.groupby(\"task_name\")[\"id\"].count().sort_values(ascending=False)\n",
    "display(kept_data.groupby(\"task_name\")[\"id\"].count())\n",
    "display(kept_data.groupby(\"task_type\")[\"id\"].count())\n",
    "# Make it a bar chart with task_name on y-axis and count on x-axis AND annotate the count on the bar\n",
    "kept_data.groupby(\"task_name\")[\"id\"].count().sort_values(ascending=False).plot.barh(figsize=(5, 5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==========================\n",
      "\u001b[1;33;40mSYSTEM:\n",
      "You are a helpful assistant assigned with the task of problem-solving. To achieve this, you will be using an interactive coding environment equipped with a variety of tool functions to assist you throughout the process.\n",
      "\n",
      "At each turn, you should first provide your step-by-step thinking for solving the task. After that, you have two options:\n",
      "\n",
      "1) Interact with a Python programming environment and receive the corresponding output. Your code should be enclosed using \"<execute>\" tag, for example: <execute> print(\"Hello World!\") </execute>.\n",
      "2) Directly provide a solution that adheres to the required format for the given task. Your solution should be enclosed using \"<solution>\" tag, for example: The answer is <solution> A </solution>.\n",
      "\n",
      "You have 5 chances to interact with the environment or propose a solution. You can only propose a solution 2 times.\n",
      "\n",
      "Tool function available (already imported in <execute> environment):\n",
      "[1] wikipedia_search(query: str) -> str\n",
      "The Wikipedia Search tool provides access to a vast collection of articles covering a wide range of topics.\n",
      "Can query specific keywords or topics to retrieve accurate and comprehensive information.\u001b[0m\n",
      "==========================\n",
      "\u001b[1;34;40mUSER:\n",
      "Task:\n",
      "Was Paul Boghossian Chair of the Department in the NYU Department of Philosophy during the same year when System of a Down was formed?\u001b[0m\n",
      "==========================\n",
      "\u001b[1;32;40mASSISTANT:\n",
      "To solve this problem, let's start by determining the year when System of a Down was formed.\n",
      "<execute> print(wikipedia_search('System of a Down')) </execute>\u001b[0m\n",
      "==========================\n",
      "\u001b[1;34;40mUSER:\n",
      "Observation:\n",
      "Page: System of a Down\n",
      "Summary: System of a Down (also known as SOAD or simply System) is an Armenian-American heavy metal band formed in Glendale, California, in 1994. Since 1997, the band has consisted of Serj Tankian (lead vocals, keyboards); Daron Malakian (guitar, vocals); Shavo Odadjian (bass, backing vocals); and John Dolmayan (drums), who replaced original drummer Andy Khachaturian.The band achieved commercial success with the release of five studio albums, three of which debuted at number one on the US Billboard 200. System of a Down has been nominated for four Grammy Awards, and their song \"B.Y.O.B.\" won a Grammy Award for Best Hard Rock Performance in 2006. The band went on hiatus in 2006 and reunited in 2010. Other than two new songs in 2020 (\"Protect the Land\" and \"Genocidal Humanoidz\"), System of a Down has not released a full-length record since the Mezmerize and Hypnotize albums in 2005. The band has sold over 12 million records worldwide, while two of their singles, \"A\n",
      "You have 4 steps left and 2 chances to propose solution left.\u001b[0m\n",
      "==========================\n",
      "\u001b[1;32;40mASSISTANT:\n",
      "According to the Wikipedia search result, System of a Down was formed in 1994.\n",
      "Now let's find out if Paul Boghossian was the Chair of the Department in the NYU Department of Philosophy during the same year.\n",
      "<execute> print(wikipedia_search('Paul Boghossian')) </execute>\u001b[0m\n",
      "==========================\n",
      "\u001b[1;34;40mUSER:\n",
      "Observation:\n",
      "Page: Paul Boghossian\n",
      "Summary: Paul Artin Boghossian (; born 1957) is an American philosopher. He is Silver Professor of Philosophy at New York University, where he is chair of the department (having also held the position from 1994 to 2004). His research interests include epistemology, the philosophy of mind, and the philosophy of language. He is also director of the New York Institute of Philosophy and Distinguished Research Professor of Philosophy at the University of Birmingham.\n",
      "\n",
      "Page: Boghossian\n",
      "Summary: Boghossian, Bogossyan, Boghosian, Bogosyan, etc. is an Armenian surname, particularly associated with Western Armenia. The Eastern Armenian equivalent is Poghossyan. It is a patronymic from the first name Boghos (Armenian: Պողոս), equivalent to Paul, making the name effectively equivalent to Paulson.\n",
      "Notable people with the name include:\n",
      "\n",
      "Alain Boghossian, French-Armenian football player and now assistant coach for the French national team.\n",
      "Paul Boghossian, professor of philosophy\n",
      "You have 3 steps left and 2 chances to propose solution left.\u001b[0m\n",
      "==========================\n",
      "\u001b[1;32;40mASSISTANT:\n",
      "According to the Wikipedia search result, Paul Boghossian was the Chair of the Department in the NYU Department of Philosophy from 1994 to 2004.\n",
      "Since System of a Down was formed in 1994, Paul Boghossian was indeed the Chair of the Department in the NYU Department of Philosophy during the same year.\n",
      "<solution> Yes </solution>\u001b[0m\n",
      "==========================\n"
     ]
    }
   ],
   "source": [
    "visualize_traj(convert_state_to_traj(kept_data.sample(1).iloc[0][\"state\"]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 6728 trajectories\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6728/6728 [00:27<00:00, 247.66it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='conversations', ylabel='Proportion'>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "output_traj = pd.concat(\n",
    "    [\n",
    "        kept_data[\"id\"],\n",
    "        kept_data[\"state\"].apply(convert_state_to_traj),\n",
    "    ],\n",
    "    axis=1\n",
    ").rename(columns={\"state\": \"conversations\"})\n",
    "print(f\"Got {len(output_traj)} trajectories\")\n",
    "output_traj_length = output_traj[\"conversations\"].progress_apply(lambda x: len(tokenizer(format_traj_to_str(x)).input_ids))\n",
    "# display(output_traj_length.plot.hist(bins=100))\n",
    "# Do a ecdf plot\n",
    "display(sns.ecdfplot(output_traj_length))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_traj.to_json(os.path.join(ROOT_DIR, \"data/datasets/oct28_full6728.jsonl\"), orient=\"records\", lines=True)\n",
    "# output_traj.to_json(os.path.join(ROOT_DIR, \"data/datasets/oct30_easy8155.jsonl\"), orient=\"records\", lines=True)\n",
    "# output_traj.to_json(os.path.join(ROOT_DIR, \"data/datasets/nov2_gpt4hard411.jsonl\"), orient=\"records\", lines=True)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm-agent",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
